/*
 * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
 * Copyright 2018 RackTop Systems.
 *
 * Licensed under the OpenSSL license (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include <string.h>
#include <openssl/bio.h>
#include <openssl/engine.h>
#include "compat.h"

#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)

static void *
OPENSSL_zalloc(size_t num)
{
	void *ret = OPENSSL_malloc(num);

	if (ret != NULL)
		(void) memset(ret, 0, num);
	return (ret);
}

int
RSA_set0_key(RSA *r, BIGNUM *n, BIGNUM *e, BIGNUM *d)
{
	/*
	 * If the fields n and e in r are NULL, the corresponding input
	 * parameters MUST be non-NULL for n and e.  d may be
	 * left NULL (in case only the public key is used).
	 */
	if ((r->n == NULL && n == NULL) || (r->e == NULL && e == NULL))
		return (0);

	if (n != NULL) {
		BN_free(r->n);
		r->n = n;
	}
	if (e != NULL) {
		BN_free(r->e);
		r->e = e;
	}
	if (d != NULL) {
		BN_free(r->d);
		r->d = d;
	}

	return (1);
}

int
RSA_set0_factors(RSA *r, BIGNUM *p, BIGNUM *q)
{
	/*
	 * If the fields p and q in r are NULL, the corresponding input
	 * parameters MUST be non-NULL.
	 */
	if ((r->p == NULL && p == NULL) || (r->q == NULL && q == NULL))
		return (0);

	if (p != NULL) {
		BN_free(r->p);
		r->p = p;
	}
	if (q != NULL) {
		BN_free(r->q);
		r->q = q;
	}

	return (1);
}

int
RSA_set0_crt_params(RSA *r, BIGNUM *dmp1, BIGNUM *dmq1, BIGNUM *iqmp)
{
	/*
	 * If the fields dmp1, dmq1 and iqmp in r are NULL, the
	 * corresponding input parameters MUST be non-NULL.
	 */
	if ((r->dmp1 == NULL && dmp1 == NULL) ||
	    (r->dmq1 == NULL && dmq1 == NULL) ||
	    (r->iqmp == NULL && iqmp == NULL))
		return (0);

	if (dmp1 != NULL) {
		BN_free(r->dmp1);
		r->dmp1 = dmp1;
	}
	if (dmq1 != NULL) {
		BN_free(r->dmq1);
		r->dmq1 = dmq1;
	}
	if (iqmp != NULL) {
		BN_free(r->iqmp);
		r->iqmp = iqmp;
	}

	return (1);
}

void
RSA_get0_key(const RSA *r, const BIGNUM **n, const BIGNUM **e, const BIGNUM **d)
{
	if (n != NULL)
		*n = r->n;
	if (e != NULL)
		*e = r->e;
	if (d != NULL)
		*d = r->d;
}

void
RSA_get0_factors(const RSA *r, const BIGNUM **p, const BIGNUM **q)
{
	if (p != NULL)
		*p = r->p;
	if (q != NULL)
		*q = r->q;
}

void
RSA_get0_crt_params(const RSA *r, const BIGNUM **dmp1, const BIGNUM **dmq1,
    const BIGNUM **iqmp)
{
	if (dmp1 != NULL)
		*dmp1 = r->dmp1;
	if (dmq1 != NULL)
		*dmq1 = r->dmq1;
	if (iqmp != NULL)
		*iqmp = r->iqmp;
}

void
DSA_get0_pqg(const DSA *d, const BIGNUM **p, const BIGNUM **q,
    const BIGNUM **g)
{
	if (p != NULL)
		*p = d->p;
	if (q != NULL)
		*q = d->q;
	if (g != NULL)
		*g = d->g;
}

int
DSA_set0_pqg(DSA *d, BIGNUM *p, BIGNUM *q, BIGNUM *g)
{
	/*
	 * If the fields p, q and g in d are NULL, the corresponding input
	 * parameters MUST be non-NULL.
	 */
	if ((d->p == NULL && p == NULL) || (d->q == NULL && q == NULL) ||
	    (d->g == NULL && g == NULL))
		return (0);

	if (p != NULL) {
		BN_free(d->p);
		d->p = p;
	}
	if (q != NULL) {
		BN_free(d->q);
		d->q = q;
	}
	if (g != NULL) {
		BN_free(d->g);
		d->g = g;
	}

	return (1);
}

void
DSA_get0_key(const DSA *d, const BIGNUM **pub_key, const BIGNUM **priv_key)
{
	if (pub_key != NULL)
		*pub_key = d->pub_key;
	if (priv_key != NULL)
		*priv_key = d->priv_key;
}

int
DSA_set0_key(DSA *d, BIGNUM *pub_key, BIGNUM *priv_key)
{
	/*
	 * If the field pub_key in d is NULL, the corresponding input
	 * parameters MUST be non-NULL.  The priv_key field may
	 * be left NULL.
	 */
	if (d->pub_key == NULL && pub_key == NULL)
		return (0);

	if (pub_key != NULL) {
		BN_free(d->pub_key);
		d->pub_key = pub_key;
	}
	if (priv_key != NULL) {
		BN_free(d->priv_key);
		d->priv_key = priv_key;
	}

	return (1);
}

void
DSA_SIG_get0(const DSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps)
{
	if (pr != NULL)
		*pr = sig->r;
	if (ps != NULL)
		*ps = sig->s;
}

int
DSA_SIG_set0(DSA_SIG *sig, BIGNUM *r, BIGNUM *s)
{
	if (r == NULL || s == NULL)
		return (0);
	BN_clear_free(sig->r);
	BN_clear_free(sig->s);
	sig->r = r;
	sig->s = s;
	return (1);
}

DSA *
EVP_PKEY_get0_DSA(EVP_PKEY *pkey)
{
	if (pkey->type != EVP_PKEY_DSA)
		return (NULL);
	return (pkey->pkey.dsa);
}

void
ECDSA_SIG_get0(const ECDSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps)
{
	if (pr != NULL)
		*pr = sig->r;
	if (ps != NULL)
		*ps = sig->s;
}

int
ECDSA_SIG_set0(ECDSA_SIG *sig, BIGNUM *r, BIGNUM *s)
{
	if (r == NULL || s == NULL)
		return (0);
	BN_clear_free(sig->r);
	BN_clear_free(sig->s);
	sig->r = r;
	sig->s = s;
	return (1);
}

void
DH_get0_pqg(const DH *dh, const BIGNUM **p, const BIGNUM **q, const BIGNUM **g)
{
	if (p != NULL)
		*p = dh->p;
	if (q != NULL)
		*q = dh->q;
	if (g != NULL)
		*g = dh->g;
}

int
DH_set0_pqg(DH *dh, BIGNUM *p, BIGNUM *q, BIGNUM *g)
{
	/*
	 * If the fields p and g in d are NULL, the corresponding input
	 * parameters MUST be non-NULL.  q may remain NULL.
	 */
	if ((dh->p == NULL && p == NULL) || (dh->g == NULL && g == NULL))
		return (0);

	if (p != NULL) {
		BN_free(dh->p);
		dh->p = p;
	}
	if (q != NULL) {
		BN_free(dh->q);
		dh->q = q;
	}
	if (g != NULL) {
		BN_free(dh->g);
		dh->g = g;
	}

	if (q != NULL) {
		dh->length = BN_num_bits(q);
	}

	return (1);
}

void
DH_get0_key(const DH *dh, const BIGNUM **pub_key, const BIGNUM **priv_key)
{
	if (pub_key != NULL)
		*pub_key = dh->pub_key;
	if (priv_key != NULL)
		*priv_key = dh->priv_key;
}

int
DH_set0_key(DH *dh, BIGNUM *pub_key, BIGNUM *priv_key)
{
	/*
	 * If the field pub_key in dh is NULL, the corresponding input
	 * parameters MUST be non-NULL.  The priv_key field may
	 * be left NULL.
	 */
	if (dh->pub_key == NULL && pub_key == NULL)
		return (0);

	if (pub_key != NULL) {
		BN_free(dh->pub_key);
		dh->pub_key = pub_key;
	}
	if (priv_key != NULL) {
		BN_free(dh->priv_key);
		dh->priv_key = priv_key;
	}

	return (1);
}

int
DH_set_length(DH *dh, long length)
{
	dh->length = length;
	return (1);
}

const unsigned char *
EVP_CIPHER_CTX_iv(const EVP_CIPHER_CTX *ctx)
{
	return (ctx->iv);
}

unsigned char *
EVP_CIPHER_CTX_iv_noconst(EVP_CIPHER_CTX *ctx)
{
	return (ctx->iv);
}

EVP_MD_CTX *
EVP_MD_CTX_new(void)
{
	return (OPENSSL_zalloc(sizeof (EVP_MD_CTX)));
}

void
EVP_MD_CTX_free(EVP_MD_CTX *ctx)
{
	(void) EVP_MD_CTX_cleanup(ctx);
	OPENSSL_free(ctx);
}

RSA_METHOD *
RSA_meth_dup(const RSA_METHOD *meth)
{
	RSA_METHOD *ret;

	ret = OPENSSL_malloc(sizeof (RSA_METHOD));

	if (ret != NULL) {
		(void) memcpy(ret, meth, sizeof (*meth));
		ret->name = OPENSSL_strdup(meth->name);
		if (ret->name == NULL) {
			OPENSSL_free(ret);
			return (NULL);
		}
	}

	return (ret);
}

int
RSA_meth_set1_name(RSA_METHOD *meth, const char *name)
{
	char *tmpname;

	tmpname = OPENSSL_strdup(name);
	if (tmpname == NULL) {
		return (0);
	}

	OPENSSL_free((char *)meth->name);
	meth->name = tmpname;

	return (1);
}

int
RSA_meth_set_priv_enc(RSA_METHOD *meth,
    int (*priv_enc) (int flen, const unsigned char *from,
    unsigned char *to, RSA *rsa, int padding))
{
	meth->rsa_priv_enc = priv_enc;
	return (1);
}

int
RSA_meth_set_priv_dec(RSA_METHOD *meth,
    int (*priv_dec) (int flen, const unsigned char *from,
    unsigned char *to, RSA *rsa, int padding))
{
	meth->rsa_priv_dec = priv_dec;
	return (1);
}

int
RSA_meth_set_finish(RSA_METHOD *meth, int (*finish) (RSA *rsa))
{
	meth->finish = finish;
	return (1);
}

void
RSA_meth_free(RSA_METHOD *meth)
{
	if (meth != NULL) {
		OPENSSL_free((char *)meth->name);
		OPENSSL_free(meth);
	}
}

int
RSA_bits(const RSA *r)
{
	return (BN_num_bits(r->n));
}

RSA *
EVP_PKEY_get0_RSA(EVP_PKEY *pkey)
{
	if (pkey->type != EVP_PKEY_RSA) {
		return (NULL);
	}
	return (pkey->pkey.rsa);
}

#endif /* OPENSSL_VERSION_NUMBER || LIBRESSL_VERSION_NUMBER */
